/**
 * @Copyright ®2015 Sinosoft Co. Ltd. All rights reserved.<br/>
 * 项目名称 : 电子商务云服务平台
 * 创建日期 : 2016年6月28日
 * 修改历史 : 
 *     1. [2016年6月30日]修改文件 by chihouliang
 * 添加Javadoc注释，更新代码规范，静态工具类增加private构造函数
 */
package com.gavinwind.inspay.common.util;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串工具类
 * @date 2015-11-24
 * @since JDK 1.5
 * @author Gavin
 * @version 1.0
 */
public class StringUtil extends org.apache.commons.lang.StringUtils {

    private StringUtil() {}

    /**
     * 存放国标一级汉字不同读音的起始区位码
     */
    static final int[] SEC_POS_VALUE_LIST = { 1601, 1637, 1833, 2078, 2274, 2302, 2433, 2594, 2787, 3106, 3212, 3472, 3635, 3722, 3730, 3858, 4027, 4086,
            4390, 4558, 4684, 4925, 5249, 5600 };

    /**
     * 存放国标一级汉字不同读音的起始区位码对应读音
     */
    static final char[] FIRST_LETTER = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'w', 'x', 'y','z' };

    /**
     * 去除字符串中的所有空格、回车、换行符、制表符，包括中间字符串中间空白内容
     * 
     * @param cStr
     *            源字符串
     * @return 处理后的字符串
     */
    public static String replaceBlank(String cStr) {
        Pattern tPattern = Pattern.compile("\\s*|\t|\r|\n");
        Matcher tMatcher = tPattern.matcher(cStr);
        String tAfter = tMatcher.replaceAll("");
        return tAfter;
    }

    /**
     * 得到c在s中的出现的索引列表
     * 
     * @param cS
     *            原字符串
     * @param cC
     *            子字符串
     * @return c在s中出现的索引列表
     */
    public static List<String> getIndexList(String cS, String cC) {
        int tX = cS.indexOf(cC);
        int tReplaceLenght = 0;
        List<String> tList = new ArrayList<String>();
        while (tX != -1) {
            tList.add(tX + "");
            cS = cS.replaceFirst(cC, "");
            tReplaceLenght = tReplaceLenght + cC.length();
            tX = cS.indexOf(cC);
            if (tX != -1) {
                tX = cS.indexOf(cC) + tReplaceLenght;
            }
        }
        return tList;
    }

    /**
     * 判断是否为数字（包括小数和整数）
     * 
     * @param cStr
     *            要判断的字符串
     * @return true/flase（是/否）
     */
    public static boolean isNumeric(String cStr) {
        Pattern tPattern = Pattern.compile("-?[0-9]*.?[0-9]*");
        Matcher tIsNum = tPattern.matcher(cStr);
        if (!tIsNum.matches()) {
            return false;
        }
        return true;
    }

    /**
     * 获取一个字符串的拼音码
     * 
     * @param cOriStr
     *            要操作的字符串
     * @return 拼音码
     */
    public static String getFirstLetter(String cOriStr) {
        String tStr = cOriStr.toLowerCase();
        StringBuffer tBuffer = new StringBuffer();
        char tCh;
        char[] tTemp;
        for (int i = 0; i < tStr.length(); i++) {
            // 依次处理str中每个字符
            tCh = tStr.charAt(i);
            tTemp = new char[] { tCh };
            byte[] tUniCode = new String(tTemp).getBytes();
            if (tUniCode[0] < 128 && tUniCode[0] > 0) {
                // 非汉字
                tBuffer.append(tTemp);
            } else {
                tBuffer.append(convert(tUniCode));
            }
        }
        return tBuffer.toString();
    }

    /**
     * 获取一个汉字的拼音首字母
     * 
     * @param cBytes
     *            要操作的字符串
     * @return 拼音首字母
     */
    public static char convert(byte[] cBytes) {
        char tResult = '-';
        int tSecPosValue = 0;
        int i;
        for (i = 0; i < cBytes.length; i++) {
            cBytes[i] -= 160;
        }
        tSecPosValue = cBytes[0] * 100 + cBytes[1];
        for (i = 0; i < 23; i++) {
            if (tSecPosValue >= SEC_POS_VALUE_LIST[i] && tSecPosValue < SEC_POS_VALUE_LIST[i + 1]) {
                tResult = FIRST_LETTER[i];
                break;
            }
        }
        return tResult;
    }

    /**
     * 比较两个字符串的大小,按拼音顺序
     * 
     * @param cStr1
     *            要操作的字符串
     * @param cStr2
     *            要操作的字符串
     * @return -1:表示str1<str2 ; 1:表示str1>str2 ;0:表示str1=str2
     */
    public static int compareString(String cStr1, String cStr2) {
        int tM = cStr1.length();
        int tN = cStr2.length();
        for (int i = 0; i < tM; i++) {
            if (i < tN) {
                if (cStr1.charAt(i) > cStr2.charAt(i)) {
                    return 1;
                } else if (cStr1.charAt(i) == cStr2.charAt(i)) {
                    if (tM == tN && i + 1 == tM) {
                        return 0;
                    } else {
                        continue;
                    }
                } else {
                    return -1;
                }
            } else {
                return 1;
            }
        }
        return -1;
    }

    /**
     * 替换字符串
     * @param cResource 要操作的字符串
     * @param cTarget 要替换的目标子串
     * @param cResult 用来替换目标子串的字符串
     * @return 替换后的字符串
     */
    public static String replaceAllStr(String cResource, String cTarget, String cResult) {
        cResource = cResource.replaceAll(cTarget, cResult);
        return cResource;
    }

    /**
     * 将object 转为 string value并去空格
     * 若object为null返回空字串
     * @param cValue
     * @return 转换后的字符串
     */
    public static String getString(Object cValue) {
        if (cValue == null) {
            return "";
        }
        return String.valueOf(cValue).trim();
    }

    /**
     * 将字符串转为整形值
     * @param cValue
     * @return 转换后的int数字
     */
    public static int parseStringToInt(String cValue) {
        try {
            if (cValue == null || cValue.trim().equals("")) {
                return 0;
            }
            return Integer.parseInt(cValue);
        } catch (Exception ex) {
            return 0;
        }
    }

    /**
     * 根据分割符','，将输入字符串转换为String数组
     * 
     * @param value
     * @return
     */
    public static String arrayToCSV(String[] cValue) {
        return arrayToDelimited(cValue, ",", true, true);
    }

    /**
     * 根据分割符，将输入字符串转换为String数组,以','分割
     * 
     * @param value
     * @return
     */

    public static String arrayToDelimited(Object[] cValue) {
        return arrayToDelimited(cValue, ",");
    }

    /**
     * 根据分割符，将输入字符串转换为String数组
     * 
     * @param cValue
     * @param delimiter
     * @return
     */
    public static String arrayToDelimited(Object[] cValue, String cDelimiter) {
        return arrayToDelimited(cValue, cDelimiter, false, false, false);
    }

    /**
     * 根据分割符，将输入字符串转换为String数组
     * 
     * @param cValue
     * @param cDelimiter
     * @return
     */
    public static String arrayToDelimited(String[] cValue, String cDelimiter) {
        return arrayToDelimited(cValue, cDelimiter, true, true);
    }

    /**
     * 根据分割符，将输入字符串转换为String数组
     * 
     * @param cValue
     * @param cEelimiter
     * @param cPrepend
     * @param cAppend
     * @return
     */
    public static String arrayToDelimited(String[] cValue, String cEelimiter, boolean cPrepend, boolean cAppend) {
        return arrayToDelimited(cValue, cEelimiter, cPrepend, cAppend, false);
    }

    /**
     * 根据分割符，将输入字符串转换为String数组
     * 
     * @param cValue
     * @param cDelimiter
     * @param cPrepend
     * @param cAppend
     * @param cEliminateDuplicates
     * @return
     */
    public static String arrayToDelimited(Object[] cValue, String cDelimiter, boolean cPrepend, boolean cAppend, boolean cEliminateDuplicates) {
        if (cDelimiter == null)
            cDelimiter = ",";
        String tRetVal = null;
        if (cValue != null) {
            StringBuffer tBuff = new StringBuffer();
            int tLength = cValue.length;
            if (tLength > 0) {
                if (cPrepend)
                    tBuff.append(cDelimiter);
                boolean tIsDuplicateValue = false;
                tBuff.append(cDelimiter); // Always make sure the tBuff starts with
                // a cDelimiter for duplicate checking
                for (int i = 0; i < tLength; i++) {
                    tIsDuplicateValue = (cEliminateDuplicates ? (tBuff.indexOf(cDelimiter + cValue[i] + cDelimiter) != -1) : false);
                    if (!tIsDuplicateValue) {
                        tBuff.append(cValue[i]);
                        if (i < tLength - 1)
                            tBuff.append(cDelimiter);
                    }
                }
                tBuff.deleteCharAt(0); // remove the cDelimiter added for checking
                // duplicates
                // If the last cValue is a duplicate cValue, remove the cDelimiter
                // added to the end of the string
                if (tIsDuplicateValue) {
                    tBuff.deleteCharAt(tBuff.length() - 1);
                }
                if (cAppend)
                    tBuff.append(cDelimiter);
            }
            tRetVal = tBuff.toString();
        }
        return tRetVal;
    }

    /** 
     * 判断页面传来的参数是否为空
     * @Title: isParamEmpty 
     * @param cParamName
     * @return
    */
    public static boolean isParamEmpty(String cParamName) {
        if (cParamName != null && !cParamName.equals("") && !cParamName.equals("null"))
            return false;
        else
            return true;
    }

    /**
     * 通过反射将字符串转换为基本数据类型
     * 
     * @author ex_xupengfei
     * @param cStr
     * @param cClass
     * @return
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public static <T> T transferString2PrimitiveType(String cStr, Class<T> cClass) throws Exception {
        T tObj = null;
        try {
            if (Boolean.class == cClass || boolean.class == cClass) {
                tObj = (T) Boolean.valueOf(cStr);
            } else if (Character.class == cClass || char.class == cClass) {
                tObj = (T) (Character) cStr.toCharArray()[0];
            } else if (Short.class == cClass || short.class == cClass) {
                tObj = (T) Short.valueOf(cStr);
            } else if (Integer.class == cClass || int.class == cClass) {
                tObj = (T) Integer.valueOf(cStr);
            } else if (Byte.class == cClass || byte.class == cClass) {
                tObj = (T) Byte.valueOf(cStr);
            } else if (Long.class == cClass || long.class == cClass) {
                tObj = (T) Long.valueOf(cStr);
            } else if (Double.class == cClass || double.class == cClass) {
                tObj = (T) Double.valueOf(cStr);
            } else if (Float.class == cClass || float.class == cClass) {
                tObj = (T) Float.valueOf(cStr);
            }
        } catch (Exception e) {
            throw new Exception(cStr + "无法转换为" + cClass.getSimpleName() + "类型");
        }
        return tObj;
    }

    /**
     * 获取指定前缀和后缀之间的内容，并返回一个内容列表
     * @param cStr 操作的目标字符串
     * @param cStart 前缀字符
     * @param cEnd 后缀字符
     * @return 挖出的子串列表
     */
    public static List<String> dugSubstrings(String cStr, char cStart, char cEnd) {
        List<String> tResult = new ArrayList<String>();
        int tIndex1 = -1;
        int tIndex2 = -1;
        while ((tIndex1 = cStr.indexOf(cStart, tIndex2 + 1)) != -1 && (tIndex2 = cStr.indexOf(cEnd, tIndex1 + 1)) != -1) {
            tResult.add(cStr.substring(tIndex1 + 1, tIndex2));
        }
        return tResult;
    }

    /**
     * 用指定符号将字符串分隔，同时支持忽略指定前缀和后缀之间的分隔符号
     * @param cStr 操作的目标字符串
     * @param cGap 分隔符
     * @param cExclude1 前缀
     * @param cExclude2 后缀
     * @return 切分后的子串数组
     */
    public static String[] splitStringByGap(String cStr, char cGap, String cExclude1, String cExclude2) {
        List<String> tStrsList = new ArrayList<String>();
        int j = -1;
        int i = j;
        j = cStr.indexOf(cGap, i + 1);
        while (j != -1) {
            int k = 0;
            if (cStr.indexOf(cExclude1) < j && (k = cStr.indexOf(cExclude2, j)) > j) {
                j = cStr.indexOf(cGap, k);
            }
            if (j != -1) {
                tStrsList.add(cStr.substring(i + 1, j));
                i = j;
                j = cStr.indexOf(cGap, i + 1);
            }
        }
        if (i != -1) {
            tStrsList.add(cStr.substring(i + 1));
        }
        return tStrsList.toArray(new String[1]);
    }
}
